# -*- coding: utf-8 -*-
#
# Autor: Joao Luis nº5613
# Tendo por base o Código fornecido na Aula
# Data: 25/03/2011
#
#

# processamento de HTML através do parser BeautifulSoup
from BeautifulSoup import BeautifulSoup
import re

# bibliteca para acesso ao  sqlite3
import sqlite3

# biblioteca para acesso através de protocolos de Internet
import urllib2

# escrita em csv
import csv



#Codigo fornecido pelo professor
#Esta funçao permite aceder ao site rebides e obter os codigos tipo estabelecimentos
#retorna uma lista com os dados
def obter_codigos_tipo_estabelecimento(ano):
    '''
    a funcao obtem os codigos dos tipos de estabelecimento
    de ensino superior
    
    ano - ano a que se referem os dados
    '''
    # url base do sistema Rebides
    URL_REBIDES = 'http://www.rebides.oces.mctes.pt/Rebides'

    # formacao do Universal Resource Locator
    # a partir do ano
    url = URL_REBIDES + '0' + str(ano)

    try:
        # abre a conexao para o site
        ficheiro = urllib2.urlopen( url )
    except:
        print "ERRO DE CONEXAO", url
        pass


    try:
        # leitura dos dados da pagina
        dados = ficheiro.read()
    except:
        print "ERRO de LEITURA"
        pass
    else:
        ficheiro.close()

    # processamento dos dados da página
    soup = BeautifulSoup(dados)

    # os codigos vao estar associados ao
    # tipo de estabelecimento
    d_tipos_estabelecimentos = {}

    lista = soup.findAll('a', )
    for x in lista:
        # href vai ter o conteudo da referencia em HTML
        href = x['href']

        # remove de href tudo menos o codigo
        href = re.sub('rebid\_m1\.asp\?codr\=', '', href)
        
        # o conteudo encontra-se do tag encontra-se aqui
        contents = x.contents
        
        # converte para utf-8
        tipo_estabelecimento = contents[0].encode('utf-8')
        d_tipos_estabelecimentos[ tipo_estabelecimento ] = href
        pass
    return d_tipos_estabelecimentos



#Este metodo permite aceder ao site rebides e obter dos codigos dos estabelecimentos
#retora uma lista com os dados
def obter_codigos_estabelecimentos(ano, codigo_tipo_estabelecimento):
    '''
    a funcao obtem os codigos dos tipos de estabelecimento
    de ensino superior
    
    ano - ano a que se referem os dados
    '''
    # url base do sistema Rebides
    URL_REBIDES = 'http://www.rebides.oces.mctes.pt/Rebides'

    # formacao do Universal Resource Locator
    # a partir do ano
    url = URL_REBIDES + '0' + str(ano)
    url = url + '/rebid_m1.asp?codr=' + codigo_tipo_estabelecimento

    try:
        # abre a conexao para o site
        ficheiro = urllib2.urlopen( url )
    except:
        print "ERRO DE CONEXAO", url
        pass


    try:
        # leitura dos dados da pagina
        dados = ficheiro.read()
    except:
        print "ERRO de LEITURA"
        pass
    else:
        ficheiro.close()

    # processamento dos dados da página
    soup = BeautifulSoup(dados)

    # os codigos vao estar associados ao
    # tipo de estabelecimento
    d_estabelecimentos = {}

    lista = soup.findAll('a', )
    for x in lista:
        # href vai ter o conteudo da referencia em HTML
        href = x['href']

        # remove de href tudo menos o codigo
        chave_procura = \
            'rebid\_m2\.asp\?CodR\={0}\&CodP\='.\
            format(codigo_tipo_estabelecimento)

        href = re.sub(chave_procura, '', href)

        # o conteudo encontra-se do tag encontra-se aqui
        contents = x.contents
        
        # converte para utf-8
        estabelecimento = contents[0].encode('utf-8')

        d_estabelecimentos[ estabelecimento ] = href
        pass

    return d_estabelecimentos


#Codigo fornecido pelo professor
#Esta funçao permite conectar ao site rebides , e retornar uma lista com a informaçao do docente
def obter_informacao_docentes(ano, tipo, codR, estabelecimento, codP):
    '''
    codR - codigo do tipo de estabelecimento
    codP - codigo do estabelecimento
    '''
    C_NOME_COMPLETO = 1
    C_GRAU = 3
    C_CURSO = 5
    C_CATEGORIA = 7
    C_REGIME = 9

    # url base do sistema Rebides
    URL_REBIDES = 'http://www.rebides.oces.mctes.pt/Rebides'

    # formacao do Universal Resource Locator
    # a partir do ano
    url = URL_REBIDES + '0' + str(ano)
    url = url + '/rebid_m2.asp?CodR=' + codR + '&CodP=' + codP 

    try:
        # abre a conexao para o site
        ficheiro = urllib2.urlopen( url )
    except:
        print "ERRO DE CONEXAO", url
        pass

    try:
        # leitura dos dados da pagina
        dados = ficheiro.read()
    except:
        print "ERRO de LEITURA"
        pass
    else:
        ficheiro.close()

    # processamento dos dados da página
    soup = BeautifulSoup(dados)
    
    lista = soup.findAll('tr', )
    
    lista_docentes = []

    for x in lista:
        nome = x.contents[C_NOME_COMPLETO].contents[0]
        
        grau = x.contents[C_GRAU].contents[0]
        grau = grau.lstrip()
        
        curso = x.contents[C_CURSO].contents[0]
        curso = curso.lstrip()

        categoria = x.contents[C_CATEGORIA].contents[0]

        regime = x.contents[C_REGIME].contents[0]

        conteudo = x.contents[11].findAll('a')
        for y in conteudo:
            # href vai ter o conteudo da referencia em HTML
            href = y['href']

            chave_procura = 'rebid\_m3\.asp\?CodD\='
            href = re.sub(chave_procura, '', href)

            chave_procura = '\&CodP\={0}'.format(codP)
            codigo_docente = re.sub(chave_procura, '', href)
            pass

        if nome != "NOME COMPLETO":
            if nome.encode('utf-8') != '&nbsp;':
                nome_completo = nome
                nome_completo = nome_completo.expandtabs()
                novo_completo = re.sub('\015', '', nome_completo)
                nome_completo = novo_completo.lstrip()
                nome_completo = nome_completo.encode('utf-8')
                
                categoria_completo = categoria.lstrip()
                categoria_completo = categoria_completo.encode('utf-8')

                regime_completo = regime.lstrip()
                regime_completo = regime_completo.encode('utf-8')
                
                codigo_docente_completo = codigo_docente
                pass

            grau_completo = grau.encode('utf-8')
            curso_completo = curso.encode('utf-8')

            informacao_docente = [ codigo_docente_completo,
                                   nome_completo,
                                   grau_completo,
                                   curso_completo,
                                   categoria_completo,
                                   regime_completo,
                                   ano,
                                   tipo,
                                   estabelecimento]
            lista_docentes.append(informacao_docente)
            pass
        pass
    return lista_docentes



#Cria uma base de dados com o nome "rebides.db"
# Cria as tabelas "tipoEstabelecimento", "estabelecimentos"
# "docentes" , "registo" , "cursos" , "categorias" , "regimes", "fichas_curso" , "registo"
def criar_db():
    
    #conn = sqlite3.connect("rebides.db")
    conn = sqlite3.connect("rebides.db")
    conn.execute('''CREATE TABLE IF NOT EXISTS tipoEstabelecimento
        (tipoEstab INTEGER ,
        nomeTipoEstab TEXT PRIMARY KEY)''')
    
    conn.execute('''CREATE TABLE IF NOT EXISTS estabelecimentos
        (idEstab INTEGER PRIMARY KEY,
        nomeEstab TEXT,
        tipoEstab INTEGER,
        FOREIGN KEY (tipoEstab) REFERENCES tipoEstabelecimento (tipoEstab))''')
    
    conn.execute('''CREATE TABLE IF NOT EXISTS docentes 
        (idDocente INTEGER ,
        nomeDocente TEXT PRIMARY KEY)''')
    
    conn.execute('''CREATE TABLE IF NOT EXISTS registo 
        (id INTEGER PRIMARY KEY AUTOINCREMENT, 
                       ano INTEGER,
                       docente REFERENCES docentes (nome_completo),
                       estabelecimento REFERENCES estabelecimentos (designacao),
                       categoria REFERENCES categorias (designacao),
                       grau REFERENCES grau (designacao),
                       regime REFERENCES regimes (designacao),
                       tipo_estabelecimento REFERENCES 
                       tipos_estabelecimento (designacao))''')
    
    conn.execute("""CREATE TABLE IF NOT EXISTS graus 
                      (designacao TEXT PRIMARY KEY)
                   """)
    conn.execute("""CREATE TABLE IF NOT EXISTS cursos
                      (designacao TEXT PRIMARY KEY)
                   """)
    conn.execute("""CREATE TABLE IF NOT EXISTS categorias
                      (designacao TEXT PRIMARY KEY)
                   """)
    conn.execute("""CREATE TABLE IF NOT EXISTS regimes
                      (designacao TEXT PRIMARY KEY)
                   """)
    
    conn.execute("""CREATE TABLE IF NOT EXISTS fichas_curso
                      (id INTEGER PRIMARY KEY AUTOINCREMENT, 
                       ano INTEGER,
                       docente REFERENCES docentes (nome_completo),
                       grau REFERENCES graus (designacao),
                       curso REFERENCES cursos (designacao))
                   """)
    
    
    
    conn.close()
    pass


# Esta função foi criada, para ir buscar os dados do tipo de estabelecimento do site rebides
# para preencher na base de dados, na tabela tipoestabelecimento
def preencher_tipos_estabelecimento(ano):
    '''
    preenchimento da tabela tipos_estabelecimento
    '''
    conn = sqlite3.connect("rebides.db")
    cursor = conn.cursor()
    print "ANO: 200{0}".format(ano)
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)

    for tipo, codR in d_tipos_estabelecimento.iteritems():
        try:
            cmd = """insert into tipoestabelecimento (tipoEstab, nomeTipoEstab)  values ('{0}' , '{1}')""".format(codR, tipo)
            cursor.execute(cmd)
            
        
        except:
            print "falhou"
            pass
        pass
    conn.commit()
    cursor.close()
    pass

#Esta função conecta á base dados rebides permite ir buscar os dados estabelecimentos , 
#e colocar na tabela estabelecimentos
# 
def preencher_estabelecimentos(ano):
    '''
    preenchimento da tabela estabelecimentos
    '''
    conn = sqlite3.connect("rebides.db")
    cursor = conn.cursor()
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)
   
    for tipo, codR in d_tipos_estabelecimento.iteritems():
        for estabelecimento, codP in obter_codigos_estabelecimentos(ano, codR).iteritems():
                print codP , '' , estabelecimento
                cmd = """insert into estabelecimentos (idEstab,nomeEstab,tipoEstab) values ('{0}', '{1}' , '{2}')""".\
                    format( codP ,estabelecimento , codR)
                  
                 
                try:
                    cursor.execute(cmd)
                    
                except:
                    continue
                pass
        pass    
    conn.commit()
    cursor.close()
    pass


#Esta funçao permite remover as tabelas da base de dados rebides.db
#São removidas as tabelas: "tipoEstabelecimento" , "estabelecimento" , "docentes", "registo",
# "graus", "cursos", "categorias", "regimes", "fichas curso"   
def remover_tabelas():
        conn = sqlite3.connect("rebides.db")
        conn.execute('''drop table registo''')
        conn.execute('''drop table estabelecimentos''')
        conn.execute('''drop table tipoEstabelecimento''')
        conn.execute('''drop table docentes''')
        conn.execute('''drop table graus''')
        conn.execute('''drop table fichas_curso''')
        conn.execute('''drop table regimes''')
        conn.execute('''drop table categorias''')
        conn.execute('''drop table cursos''')
        conn.close()
        pass   
    

## Esta funçao recebe uma lista como parametro com os dados do docente, 
#E na base dados rebides.db, preenche a tabela docentes com os dados da lista     
def preencher_docentes(lista):
    C_CODIGO = 0
    C_DOCENTE = 1

    conn = sqlite3.connect("rebides.db")
    cursor = conn.cursor()
    # uma linha corresponde a uma entrada 
    for linha in lista:
        for x in linha:
            cmd = """insert into docentes (idDocente, nomeDocente) values ({0}, '{1}')""".\
                format(x[C_CODIGO], x[C_DOCENTE])
            #print cmd
            try:
                cursor.execute(cmd)
                conn.commit()
                print "Entrou na base de dados com sucesso "
            except:
               # print x[C_DOCENTE]
                print " Nao entrou nome repetido"
                continue
            pass
        pass
    
    cursor.close()
    pass


# Esta função foi criada para retornar a lista , com o determinado "tipo" de dados 
# o parametro pode ser graus , cursos , categorias, regimes
def organizar_conjuntos_unicos(lista_entrada, tipo):
    d_informacao = {}
    d_informacao['graus'] = 2
    d_informacao['cursos'] = 3
    d_informacao['categorias'] = 4
    d_informacao['regimes'] = 5
    d_informacao['estabelecimentos'] = 8

    conjunto_unico = set()
    lista = []
    for ld in lista_entrada:
        for x in ld:
            conjunto_unico.add(x[d_informacao[tipo]])
            pass
        pass
    
    for y in conjunto_unico:
        lista.append(y)
        pass

    return lista


# Esta função permite conectar á base de dados rebides.db , e consoante o "tipo" de dados que é enviado
#para o paramentro tipo , vais ser prenchido na tabela que tem como referencia (designacao)
def preencher_geral(lista, tipo):
    d_informacao = {}
    d_informacao['graus'] = 2
    d_informacao['cursos'] = 3
    d_informacao['categorias'] = 4
    d_informacao['regimes'] = 5
    d_informacao['estabelecimentos'] = 8
    
    conn = sqlite3.connect("rebides.db")
    cursor = conn.cursor()
    for x in lista:
        cmd = """insert into {0} (designacao) values ('{1}')""".\
            format(tipo,x)

        try:
            cursor.execute(cmd)
            
            print "entrouuuuuuuuuuuu"
        except:
            #print tipo, x
            print "naou entrouuuuuuuuuu"
            pass
        pass
    conn.commit()
    pass

# Codigo fornecido pelo professor
# Esta função permite conectar á base de dados rebides.db , e preencher a tabela fichas curso 
def preencher_fichas_curso(lista ):
    C_CODIGO = 0
    C_DOCENTE = 1
    C_GRAU = 2
    C_CURSO = 3
    C_ANO = 6

    conn = sqlite3.connect("rebides.db")
    cursor= conn.cursor()
    # uma linha corresponde a uma entrada 
    for linha in lista:
        for x in linha:
            # selecciona a referência do grau
            cmd = """SELECT designacao FROM graus WHERE designacao = '{0}'""".\
                format(x[C_GRAU])
            try:
                cursor.execute(cmd)
                r = cursor.fetchone()
                grau = r[0]
            except:
                continue

            # selecciona a referência do curso
            cmd = """SELECT designacao FROM cursos WHERE designacao = '{0}'""".\
                format(x[C_CURSO])
            try:
                cursor.execute(cmd)
                r = cursor.fetchone()
                curso = r[0]
            except:
                continue

            # selecciona a referência do docente
            cmd = """SELECT nomeDocente FROM docentes where nomeDocente = '{0}'""".\
                format(x[C_DOCENTE])
            try:
                cursor.execute(cmd)
                r = cursor.fetchone()
                docente = r[0]
            except:
                continue

            # insere na base de dados
            cmd = """INSERT INTO fichas_curso 
                     (ano, docente, grau, curso)
                     VALUES 
                     ('{0}','{1}','{2}','{3}') """.\
                format(x[C_ANO], 
                       docente.encode('utf-8'), 
                       grau.encode('utf-8'), 
                       curso.encode('utf-8'))
            try:
                cursor.execute(cmd)
                print "ENTROUUUUUU FICHAS"
                conn.commit()
            except:
                continue
                print "NAAAAOOOOOO ENNNTROUUUUU"
            pass

        
        pass

    
    
    
    pass

#codigo Fornecido pelo professor, no entanto foi acrescentado a referencia graus, para ser possivel 
#efectuar estatisticas totalDocentesPorDegreeEstAno e totalDocentesPorDegreeAno
# Esta funçao permite conectar á base dados rebides.db ,  recebe a lista (com dados) como parametro 
# preenche os dados da tabela fichas_docencia

def preencher_fichas_docencia(lista):
    C_CODIGO = 0
    C_DOCENTE = 1
    C_GRAU = 2
    C_CURSO = 3
    C_CATEGORIA = 4
    C_REGIME = 5
    C_ANO = 6
    C_TIPO_ENSINO = 7
    C_ESTABELECIMENTO = 8
    
    
    conn = sqlite3.connect("rebides.db")
    cursor = conn.cursor()
    # uma linha corresponde a uma entrada 
    for linha in lista:
        for x in linha:
            # selecciona a referência do docente
            cmd = """SELECT nomeDocente FROM docentes WHERE nomeDocente = '{0}'""".\
                format(x[C_DOCENTE])
            try:
                print "registo.."
                cursor.execute(cmd)
                r = cursor.fetchone()
                docente = r[0].encode('utf-8')
                
            except:
                print"nao fez o select dos docentes"
                continue

            # selecciona a referência do estabelecimento
            cmd = """SELECT nomeEstab FROM estabelecimentos
                     WHERE nomeEstab = '{0}'""".\
                format(x[C_ESTABELECIMENTO])
            try:
                print "registo.."
                cursor.execute(cmd)
                r = cursor.fetchone()
                estabelecimento = r[0].encode('utf-8')
            except:
                print"nao fez o select dos estabelecimentos"
                continue

            # selecciona a referência da categoria
            cmd = """SELECT designacao FROM categorias WHERE designacao = '{0}'""".\
                format(x[C_CATEGORIA])
            try:
                print "registo.."
                cursor.execute(cmd)
                r = cursor.fetchone()
                categoria = r[0].encode('utf-8')
            except:
                print"nao fez o select dos categorias"
                continue
            #selecciona a referencia graus
            cmd = """SELECT designacao FROM graus WHERE designacao = '{0}'""".\
                    format(x[C_GRAU])
                
            try:
                    print "registo Graus"
                    cursor.execute(cmd)
                    r = cursor.fetchone()
                    grau = r[0].encode('utf-8')
            except:
                    print "nao fez o select dos graus"
                    continue

            # selecciona a referência do regime
            cmd = """SELECT designacao FROM regimes WHERE designacao = '{0}'""".\
                format(x[C_REGIME])
            try:
                print "registo.."
                cursor.execute(cmd)
                r = cursor.fetchone()
                regime = r[0].encode('utf-8')
            except:
                print " nao preencheu tabela regimes"
                continue

            # selecciona a referência do tipo de estabelecimento
            cmd = """SELECT nomeTipoEstab FROM tipoEstabelecimento 
                     WHERE nomeTipoEstab = '{0}'""".\
                format(x[C_TIPO_ENSINO])
            try:
                print "registo.."
                cursor.execute(cmd)
                r = cursor.fetchone()
                tipo_estabelecimento = r[0].encode('utf-8')
            except:
                print "nao preencheu tabela tipo estabelecimento"
                continue

            # insere na base de dados
            cmd = """INSERT INTO registo
                     (ano, 
                      docente, 
                      estabelecimento, 
                      categoria,
                      grau,
                      regime, 
                      tipo_estabelecimento)
                     VALUES 
                     ('{0}', '{1}', '{2}', '{3}', '{4}', '{5}','{6}') 
                  """.format(x[C_ANO], docente, estabelecimento, categoria, 
                             grau,regime, tipo_estabelecimento)
            
                     
                     
            try:
                cursor.execute(cmd)
                conn.commit()
            except:
                continue
            pass
        pass

   
    pass   


#Esta funçao conecta á base dados rebides.db e preenche todas as tabelas atraves do metodos chamados 
# cria uma lista com informacao_docentes(ano, tipo,codR, estabelecimento, codP)
def preencher_tabelas_gerais(ano):
    
    conn = sqlite3.connect("rebides.db")
    cursor = conn.cursor()
    preencher_tipos_estabelecimento(ano)
    preencher_estabelecimentos(ano)
    print "ANO: 200{0}".format(ano)
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)

    lista = []
    for tipo, codR in d_tipos_estabelecimento.iteritems():
        print tipo, ' ', codR

        d_estabelecimentos = obter_codigos_estabelecimentos(ano, codR)
        for estabelecimento, codP in d_estabelecimentos.iteritems():
            # obtem a informação de um docente
            ld = obter_informacao_docentes(ano, tipo, 
                                           codR, estabelecimento, codP)
            lista.append(ld)
            pass
        pass
    # preenche a informação geral comum
    lista_unica = organizar_conjuntos_unicos(lista, 'graus')
    # chama o metodo preencher_geral para prencher a tabela tipo "graus"
    #levando como parametro  a lista e o tipo
    preencher_geral(lista_unica, 'graus')
    # chama o metodo preencher_geral para prencher a tabela tipo "cursos"
    #levando como parametro  a lista e o tipo
    lista_unica = organizar_conjuntos_unicos(lista, 'cursos')
    preencher_geral(lista_unica, 'cursos')
    # chama o metodo preencher_geral para prencher a tabela tipo "regimes"
    #levando como parametro  a lista e o tipo
    lista_unica = organizar_conjuntos_unicos(lista, 'regimes')
    preencher_geral(lista_unica, 'regimes')
    # chama o metodo preencher_geral para prencher a tabela tipo "categorias"
    #levando como parametro  a lista e o tipo
    lista_unica = organizar_conjuntos_unicos(lista, 'categorias')
    preencher_geral(lista_unica, 'categorias')

    # preenchimento da informação de cada docente
    preencher_docentes(lista)
    #print lista
    # preencher ficha de cursos
    preencher_fichas_curso(lista)
    cursor.close()

    #preencher fichas docencia
    preencher_fichas_docencia(lista)
    cursor.close()
    pass


#Esta funçao conecta com a base dados rebides.db , permite efectuar uma consulta e uma estatistica
#faz uma consulta do id e o docente da tabela registo, consoante o ano 
#Conta quantos professores existem nesse ano
#retorna uma lista com os dados calculados
#recebe como parametro o ano
def totalDocentesAno(ano):
    conn = sqlite3.connect("rebides.db")
    c = conn.cursor()
    lista=[]
    cmd = """SELECT DISTINCT id , docente
                    FROM registo
                    WHERE  ano = {0}""".\
                    format(ano)
   
    c.execute(cmd)

    numeroDocentes = 0
    counter = 0
    for row in c:
        
        counter = counter +1
    print "Estatisticas:" 
    print "No ANO: 200{0}".format(ano)
    print "Existem " , counter , "professores no Ensino Superior"
    conteudoLista= [counter]
    lista.append(conteudoLista)
    pass    
    return lista

#Esta funçao conecta com a base dados rebides.db , permite efectuar uma consulta e uma estatistica
#Faz uma consulta do id, do tipo_estabelecimento e do ano, da tabela registo 
#Conta quantos professores existem em cada tipo_estabelecimento num determinado ano
#retorna uma lista com tipo de estabelecimentos e dados calculados
#recebe como parametro o ano
def totalDocentesPorTipoEstabAno( ano):
    conn = sqlite3.connect("rebides.db")
    c = conn.cursor()
    print "Estatisticas:" 
    print "No ANO: 200{0}".format(ano)
    lista=[]
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)
    for tipo, codR in d_tipos_estabelecimento.iteritems():
        cmd = """SELECT DISTINCT id, tipo_estabelecimento , ano
                        FROM registo
                        WHERE  ((tipo_estabelecimento) Like '{0}') and ano = {1} """.\
                        format(tipo,ano)
        c.execute(cmd)
        counter = 0
        for row in c:
            counter = counter +1
            
        #print  "Existem " , counter , "professores na instituição" , tipo, "no ano 200",ano
        conteudoLista = [tipo , counter]
        lista.append(conteudoLista)
    pass    
    return lista

#Esta funçao conecta com a base dados rebides.db , permite efectuar uma consulta e uma estatistica
# Faz uma consulda do id do estabelecimento e do ano, da tabela registo 
#Conta quantos professores existem em cada estabelecimento num determinado ano
#retorna uma lista  estabelecimentos e dados calculados
#recebe como parametro o ano
def totalDocentesPorEstabAno(ano):
    conn = sqlite3.connect("rebides.db")
    c = conn.cursor()
    lista=[]
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)
    for tipo, codR in d_tipos_estabelecimento.iteritems():
        for estabelecimento, codP in obter_codigos_estabelecimentos(ano, codR).iteritems():
            cmd = """SELECT DISTINCT id, estabelecimento , ano
                            FROM registo
                            WHERE  ((estabelecimento) Like '{0}') and ano = {1} """.\
                            format(estabelecimento,ano)
            c.execute(cmd)
            counter = 0
            for row in c:
                counter = counter +1
            #print  "Existem " , counter , "professores no estabelecimento" , estabelecimento, "no ano 200",ano
            #return counter
            listaConteudo =[estabelecimento , counter]
            lista.append(listaConteudo)
    pass    
    return lista

#Esta funçao conecta com a base dados rebides.db , permite efectuar uma consulta e uma estatistica
# faz uma consulta do docente, do grau e do ano, da tabela registo 
#Conta quantos professores existem em cada grau num determinado ano
#retorna uma lista com os graus e dados calculados
#recebe como parametro o ano e grau
def totalDocentesPorDegreeAno(grau,ano):
    conn = sqlite3.connect("rebides.db")
    c = conn.cursor()
    lista = []
    
    cmd = """SELECT DISTINCT  docente , grau , ano
                            FROM registo
                            WHERE  ((grau) Like '{0}') and ano = {1} """.\
                            format(grau,ano)
    c.execute(cmd)
    counter = 0
   
    for row in c:
        
        counter = counter +1
    
    #print  "Existem " , counter , "professores no grau", grau," no ano 200",ano
        #return counter
    listaConteudo = [grau , counter]
    lista.append(listaConteudo)
    pass  
    return lista


#Esta funçao conecta com a base dados rebides.db , permite efectuar uma consulta e uma estatistica
# faz uma consulta do docente, do estabelecimento, do ano, e grau, da tabela registo 
#Conta quantos professores existem em cada estabelecimento num grau num determinado ano
#retorna uma lista com o grau e estabelecimentos e dados calculados
#recebe como parametro o ano e grau
def totalDocentesPorDegreeEstAno(grau,ano):
    conn = sqlite3.connect("rebides.db")
    c = conn.cursor()
    lista=[]
    
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)
    for tipo, codR in d_tipos_estabelecimento.iteritems():
        for estabelecimento, codP in obter_codigos_estabelecimentos(ano, codR).iteritems():
            cmd = """SELECT DISTINCT docente, estabelecimento , ano , grau
                            FROM registo
                            WHERE  ((estabelecimento) Like '{0}') and ano = {1} and ((grau) Like '{2}')""".\
                            format(estabelecimento,ano,grau)
            c.execute(cmd)
            counter = 0
            for row in c:
                counter = counter +1
            print  "Existem " , counter , "professores no estabelecimento" , estabelecimento,"no grau",grau, "no ano 200",ano
            #return counter
            listaConteudo = [grau, estabelecimento , counter]
            lista.append(listaConteudo)
    pass      
    return lista


#este metodo permite escrever ficheiro em csv
# Codigo fornecido pelo professor
#recebe como parametro nameFile e lista
def writeCsv( nameFile, dados):
        '''
        escrita dos dados em ficheiro csv
        '''
        ficheiro = open(nameFile,"wb")
        csvwriter = csv.writer( ficheiro, delimiter=',')
        
        for escreve in dados:
            csvwriter.writerow(escreve)
            pass
        ficheiro.close()
        pass

#Este metodo permite escrever ficheiro em html
#recebe como parametro fileName , e dados
def writeHtml( fileName, dados):
        ficheiro = open(fileName,"wb")
        ficheiro.write('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">')
        ficheiro.write("<html>")
        ficheiro.write("<head>")
        ficheiro.write("<title> 5613 -João Luís 1º Trabalho LP/title>")
        ficheiro.write("</head>")
        ficheiro.write("<body>")
        ficheiro.write("<h4>" + dados +"</h4>")
        ficheiro.write("</body>")
        ficheiro.write("</html>")
        ficheiro.close()
        pass


#Este metodo permite retornar uma mensagem com os dados da estatistica
#recebe como parametro o ano
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemTotalDocAno(ano): 
        dadosDocentesAno = totalDocentesAno(ano)
        msnServidor = "Total Docentes do ensino Superior no ano de 200{0}: <br><br>".\
                    format(ano) 

        menssagem = "Total Docentes do ensino Superior no ano de 200{0}: \n\n".\
                            format(ano)
        
        for posicao in dadosDocentesAno:
            menssagem = menssagem +  str(posicao[0]) + " Docentes " + "\n"
            msnServidor= msnServidor +  str(posicao[0]) + " Docentes " + "\n"
            pass
        
        writeCsv('TotalDocentesNoEnsinoSuperiorAno200{0}.csv'.format(ano), dadosDocentesAno)
        writeHtml('TotalDocentesNoEnsinoSuperiorAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass

#Este metodo permite retornar uma mensagem com os dados da estatistica
#recebe como parametro o ano
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemTotalDocTipoAno( ano): 
        
        dadosDocentes = totalDocentesPorTipoEstabAno(ano)
        msnServidor = "Total docentes por Tipo de Estabelecimento no ano de 200{0}: <br><br>".\
                    format(ano) 
        menssagem = "Total docentes por Tipo de Estabelecimento no ano de 200{0}: \n\n".\
                            format(ano)
       
        for posicao in dadosDocentes:
            menssagem = menssagem + (str(posicao[0]).decode('utf8')) + " = " + str(posicao[1]) + " Docentes " + "\n"
            msnServidor= msnServidor + (str(posicao[0]).decode('utf8')) + " = " + str(posicao[1]) + " Docentes " +  "<br>"

            pass
        
        writeCsv('TotalDocentesPorTipoInstituicaoAno200{0}.csv'.format(ano), dadosDocentes)
        writeHtml('totalDocentesPorTipoInstituicaoAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass

#Este metodo permite retornar uma mensagem com os dados da estatistica
#recebe como parametro o ano
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemTotalDocEstAno(ano): 
        
        dadosDocentes = totalDocentesPorEstabAno(ano)
        msnServidor = "Total docentes por Estabelecimento no ano  200{0}: <br><br>".\
                    format(ano) 
        menssagem = "Total docentes por Estabelecimento no ano de 200{0}: \n\n".\
                            format(ano)
        
       
        for posicao in dadosDocentes:
            menssagem = menssagem + (str(posicao[0]).decode('utf8')) + " = " + str(posicao[1]) + " Docentes " + "\n"
            msnServidor= msnServidor + (str(posicao[0]).decode('utf8')) + " = " + str(posicao[1]) + " Docentes " + "<br>"
            pass
        
        writeCsv('TotalDocentesPorEstabelecimentosAno200{0}.csv'.format(ano), dadosDocentes)
        writeHtml('TotalDocentesPorEstabelecimentosAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass
    
#Este metodo permite retornar uma mensagem com os dados da estatistica
#recebe como parametro o ano
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemTotalDegAno(grau,ano): 
        
        dadosDocentes = totalDocentesPorDegreeAno(grau,ano)
        msnServidor = "Total docentes por grau no ano de  200{0}: <br><br>".\
                    format(ano)
        menssagem = "Total docentes por grau no ano de 200{0}: \n\n".\
                            format(ano)
       
        
        for posicao in dadosDocentes:
            menssagem = menssagem   +"Grau -" +(posicao[0]) +" = " + str(posicao[1]) + " Docentes " + "\n"
            msnServidor= msnServidor+"Grau -" +(posicao[0]) +" = " + str(posicao[1]) + " Docentes " + "<br>"
            pass
        
        writeCsv('TotalDocentesPorGrauAno200{0}.csv'.format(ano), dadosDocentes)
        writeHtml('TotalDocentesPorGrauAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass

#Este metodo permite retornar uma mensagem com os dados da estatistica
#recebe como parametro o ano e o grau
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemTotalDegEstAno(grau,ano): 
        
        dadosDocentes = totalDocentesPorDegreeEstAno(grau,ano)
        msnServidor = "Total docentes por grau e por estabelecimento no ano de  200{0}: <br><br>".\
                    format(ano)
        menssagem = "Total docentes por grau e por estabelecimento no ano de 200{0}: \n\n".\
                            format(ano)
       
        
        for posicao in dadosDocentes:
            menssagem = menssagem + (str(posicao[1]).decode('utf8'))+"," +"Grau -" +(posicao[0]) +" = " + str(posicao[2]) + " Docentes " + "\n"
            msnServidor= msnServidor+(str(posicao[1]).decode('utf8'))+"," +"Grau -" +(posicao[0]) +" = " + str(posicao[2]) + " Docentes "  + "<br>"
            pass
        
        writeCsv('TotalDocentesPorGrauPorEstabelecimentoNoAno200{0}.csv'.format(ano), dadosDocentes)
        writeHtml('TotalDocentesPorGrauPorEstabelecimentoNoAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass
    

#Este metodo permite conectar á base dados rebides.db , faz uma consulta aos estabelecimentos
# de um determinado ano
# retorna uma lista com os dados do estabelecimento
#recebe como parametro o ano 
def generateListEstAno(ano):
    
    conn = sqlite3.connect("rebides.db")
    c = conn.cursor()
    lista=[]
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)
    for tipo, codR in d_tipos_estabelecimento.iteritems():
        for estabelecimento, codP in obter_codigos_estabelecimentos(ano, codR).iteritems():
            cmd = """SELECT DISTINCT id, estabelecimento , ano
                            FROM registo
                            WHERE  ((estabelecimento) Like '{0}')  """.\
                            format(estabelecimento,ano)
            c.execute(cmd)
            
            listaConteudo =[estabelecimento]
            lista.append(listaConteudo)
    pass    
    return lista

#Este metodo permite retornar uma mensagem com os dados da Lista
#recebe como parametro o ano
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemListEstAno(ano): 
        
        dadosDocentes = generateListEstAno(ano)
        msnServidor = "Lista dos estabelecimentos no ano de  200{0}: <br><br>".\
                    format(ano)
        menssagem = "Lista dos estabelecimentos no ano de 200{0}: \n\n".\
                            format(ano)
       
        
        for posicao in dadosDocentes:
            menssagem = menssagem + (str(posicao[0]).decode('utf8')) + "\n"
            msnServidor= msnServidor+ (str(posicao[0]).decode('utf8')) + "<br>"
            pass
        
        writeCsv('ListasEstabelecimentoAno200{0}.csv'.format(ano), dadosDocentes)
        writeHtml('ListasEstabelecimentoAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass

#Este metodo permite conectar á base dados rebides.db , faz uma consulta aos estabelecimentos
# de um determinado ano
# retorna uma lista com os dados do estabelecimento e do tipo de estabelecimentos
#recebe como parametro o ano 
def generateListTipoEstAno(ano):
    
    conn = sqlite3.connect("rebides.db")
    c = conn.cursor()
    lista=[]
    d_tipos_estabelecimento = obter_codigos_tipo_estabelecimento(ano)
    for tipo, codR in d_tipos_estabelecimento.iteritems():
        for estabelecimento, codP in obter_codigos_estabelecimentos(ano, codR).iteritems():
            cmd = """SELECT DISTINCT id, estabelecimento , ano
                            FROM registo
                            WHERE  ((estabelecimento) Like '{0}') and ((tipo_estabelecimento) Like '{1}') """.\
                            format(estabelecimento,tipo)
            c.execute(cmd)
            
            listaConteudo =[estabelecimento,tipo]
            lista.append(listaConteudo)
    pass    
    return lista    

#Este metodo permite retornar uma mensagem com os dados da Lista
#recebe como parametro o ano
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemListTipoEstAno(ano): 
        
        dadosDocentes = generateListTipoEstAno(ano)
        msnServidor = "Lista dos tipos/estabelecimentos no ano de  200{0}: <br><br>".\
                    format(ano)
        menssagem = "Lista dos tipos/estabelecimentos no ano de 200{0}: \n\n".\
                            format(ano)
       
        
        for posicao in dadosDocentes:
            menssagem = menssagem + (str(posicao[0]).decode('utf8'))+"-" + (str(posicao[1]).decode('utf8'))  + "\n"
            msnServidor= msnServidor+ (str(posicao[0]).decode('utf8'))+"-" + (str(posicao[1]).decode('utf8')) + "<br>"
            pass
        
        writeCsv('ListasTipoEstabelecimentoAno200{0}.csv'.format(ano), dadosDocentes)
        writeHtml('ListasTipoEstabelecimentoAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass
    
#Este metodo permite conectar á base dados rebides.db , faz uma consulta aos docentes , graus
# de um determinado ano
# retorna uma lista com dados do docentes , e de um grau 
#recebe como parametro o ano 
def generateListDocDegAno(ano):
    
        conn = sqlite3.connect("rebides.db")
        cursor = conn.cursor() 
        listaGraus = ["Doutoramento"]
        lista =[]
        for grau in listaGraus: 
            cmd = """SELECT DISTINCT (docente), grau, ano
                    FROM registo WHERE grau LIKE '{0}'
                    """.format(grau)
            cursor.execute(cmd)
            
            for row in cursor:
                docente = row[0]
                grau = row[1]
                
                lista = [docente, grau]
                lista.append(lista)
                pass
            pass
        return lista       
        pass

#Este metodo permite retornar uma mensagem com os dados da Lista
#recebe como parametro o ano
#Cria tambem um ficheiro csv e html chamando os metodos writeCsv e writeHtml
def mensagemListDocDegAno(ano): 
        
        dadosDocentes = generateListDocDegAno(ano)
        msnServidor = "Lista dos Titulares do grau Doutoramento no ano de  200{0}: <br><br>".\
                    format(ano)
        menssagem = "Lista dos Titulares do grau Doutoramento no ano de 200{0}: \n\n".\
                            format(ano)
       
        
        for posicao in dadosDocentes:
            menssagem = menssagem + (str(posicao[0]).decode('utf8'))+"-" + (str(posicao[1]).decode('utf8'))  + "\n"
            msnServidor= msnServidor+ (str(posicao[0]).decode('utf8'))+"-" + (str(posicao[1]).decode('utf8')) + "<br>"
            pass
        
        writeCsv('ListasDocentesGrausAno200{0}.csv'.format(ano), dadosDocentes)
        writeHtml('ListasDocentesGrausAno200{0}.html'.format(ano), msnServidor)
        return menssagem    
        pass


    
    




